🧠 Gestione della Memoria in C

#include <stdio.h>

void funzione_esempio(int parametro) {
    // Tutto questo va sullo STACK:
    int locale1 = 10;           // 4 bytes sullo stack
    char locale2 = 'A';        // 1 byte sullo stack
    int array[5];              // 20 bytes sullo stack
    
    printf("Variabili locali: %d, %c\n", locale1, locale2);
    
    // Quando la funzione termina, PUFF! 💨
    // Tutto viene automaticamente rimosso dallo stack.
    // Non devi fare nulla!
}

int main(void) {
    funzione_esempio(42);
    
    // A questo punto, locale1, locale2 e array
    // non esistono più! La memoria è stata liberata.
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int* crea_array_dinamico(int dimensione) {
    // Allochiamo memoria sull'HEAP
    // Questa memoria SOPRAVVIVE alla funzione!
    int *array = (int*)malloc(dimensione * sizeof(int));
    
    if (array == NULL) {
        fprintf(stderr, "Errore: memoria insufficiente!\n");
        return NULL;
    }
    
    // Inizializziamo l'array
    for (int i = 0; i < dimensione; i++) {
        array[i] = i * i;
    }
    
    // Restituiamo il puntatore
    // La memoria è ancora lì, sull'heap!
    return array;
}

int main(void) {
    int *mio_array = crea_array_dinamico(10);
    
    if (mio_array != NULL) {
        // Possiamo usare l'array qui!
        // È sopravvissuto alla fine di crea_array_dinamico()
        for (int i = 0; i < 10; i++) {
            printf("%d ", mio_array[i]);
        }
        printf("\n");
        
        // CRUCIALE: Dobbiamo liberare la memoria!
        // Se non lo facciamo = MEMORY LEAK! 💀
        free(mio_array);
    }
    
    return 0;
}

// Prototipo:
void* malloc(size_t size);

// Come si usa:
int *ptr = (int*)malloc(5 * sizeof(int));
//           ↑               ↑
//           |               |
//      Cast a int*    Alloca 20 bytes (5 interi)

#include <stdio.h>
#include <stdlib.h>

void esempio_malloc_completo(void) {
    // Allocazione corretta con controllo
    int *numeri = (int*)malloc(5 * sizeof(int));
    
    // ✅ SEMPRE controlla se malloc() è riuscita!
    if (numeri == NULL) {
        fprintf(stderr, "Errore: impossibile allocare memoria\n");
        return;
    }
    
    // Inizializza manualmente (contiene spazzatura!)
    for (int i = 0; i < 5; i++) {
        numeri[i] = i * 10;
    }
    
    // Usa la memoria
    for (int i = 0; i < 5; i++) {
        printf("%d ", numeri[i]);
    }
    printf("\n");
    
    // ✅ SEMPRE libera quando hai finito!
    free(numeri);
    
    // ✅ BUONA PRATICA: Imposta a NULL dopo free()
    numeri = NULL;
}

// Prototipo:
void* calloc(size_t num, size_t size);
//           ↑            ↑
//    Numero elementi   Dimensione di ogni elemento

// Esempio:
int *numeri = (int*)calloc(5, sizeof(int));
// Alloca 5 interi E li inizializza tutti a 0

// Equivalente a:
int *numeri2 = (int*)malloc(5 * sizeof(int));
if (numeri2 != NULL) {
    memset(numeri2, 0, 5 * sizeof(int));
}

// Prototipo:
void* realloc(void *ptr, size_t new_size);
//           ↑              ↑
//    Puntatore vecchio   Nuova dimensione

// Esempio pratico:
int *array = (int*)malloc(5 * sizeof(int));
// array ora ha spazio per 5 interi

// Oh no! Ci servono 10 interi!
int *temp = (int*)realloc(array, 10 * sizeof(int));

if (temp == NULL) {
    // realloc() fallita! Ma array è ancora valido!
    fprintf(stderr, "Errore ridimensionamento\n");
    free(array);  // Libera il vecchio blocco
} else {
    // Successo! Ora temp punta a un blocco da 10 interi
    array = temp;
    // I primi 5 interi sono conservati!
    // Gli altri 5 sono non inizializzati (spazzatura)
}

// Prototipo:
void free(void *ptr);

// Uso:
int *numeri = (int*)malloc(10 * sizeof(int));

// ... usa numeri ...

free(numeri);  // Libera la memoria
numeri = NULL;  // ✅ BUONA PRATICA!

// ❌ MEMORY LEAK - Esempio 1
void funzione_che_perde(void) {
    int *ptr = (int*)malloc(100 * sizeof(int));
    
    // ... usa ptr ...
    
    // Oops! Dimenticato di fare free(ptr)!
    // Quando la funzione termina, perdiamo il puntatore
    // ma la memoria rimane allocata → LEAK!
}

// ❌ MEMORY LEAK - Esempio 2 (più subdolo)
void funzione_che_perde_2(void) {
    char *str = (char*)malloc(100);
    
    if (str == NULL) {
        return;  // OK, niente da liberare
    }
    
    // ... codice ...
    
    if (condizione_errore) {
        return;  // ❌ LEAK! Dimenticato free(str)
    }
    
    free(str);  // Questo free() non viene mai eseguito se c'è errore!
}

// ✅ CORRETTO - Sempre libera prima di uscire
void funzione_corretta(void) {
    char *str = (char*)malloc(100);
    
    if (str == NULL) {
        return;
    }
    
    // ... codice ...
    
    if (condizione_errore) {
        free(str);  // ✅ Libera prima di uscire!
        return;
    }
    
    free(str);  // ✅ Libera anche nel path normale
}

// ❌ DANGLING POINTER - Esempio 1
int *ptr = (int*)malloc(sizeof(int));
*ptr = 42;

free(ptr);  // Memoria liberata

// ptr ANCORA punta a quell'indirizzo!
// Ma la memoria non è più nostra!

printf("%d\n", *ptr);  // ❌ COMPORTAMENTO INDEFINITO!
                          // Potrebbe stampare 42, 0, spazzatura, o CRASH!

// ✅ SOLUZIONE: Imposta sempre a NULL dopo free()
int *ptr2 = (int*)malloc(sizeof(int));
*ptr2 = 42;

free(ptr2);
ptr2 = NULL;  // ✅ Ora è chiaro che non è più valido

if (ptr2 != NULL) {
    printf("%d\n", *ptr2);  // Questo non verrà eseguito
}

// ❌ DANGLING POINTER - Esempio 2 (più pericoloso)
int* restituisce_locale(void) {
    int x = 42;
    return &x;  // ❌ PERICOLO! x è sullo stack!
    // Quando la funzione termina, x non esiste più
    // Ma stiamo restituendo il suo indirizzo!
}

int main(void) {
    int *ptr = restituisce_locale();
    // ptr punta a memoria che non esiste più!
    // È un DANGLING POINTER!
    
    printf("%d\n", *ptr);  // ❌ COMPORTAMENTO INDEFINITO!
    
    return 0;
}

// ❌ DOUBLE FREE
int *ptr = (int*)malloc(sizeof(int));
*ptr = 10;

free(ptr);   // Prima free - OK
free(ptr);   // ❌ CRASH! Double free!

// Perché è così pericoloso?
// Dopo la prima free(), la memoria potrebbe essere stata
// riassegnata a qualcun altro. La seconda free() corrompe
// le strutture interne dell'heap manager → CRASH!

// ✅ PREVENZIONE: Imposta a NULL dopo free()
int *ptr2 = (int*)malloc(sizeof(int));
*ptr2 = 10;

free(ptr2);
ptr2 = NULL;  // ✅ Protezione

free(ptr2);  // Ora è sicuro (free(NULL) non fa nulla)

// ❌ BUFFER OVERFLOW
int *array = (int*)malloc(5 * sizeof(int));

// Array ha spazio per indici 0-4
for (int i = 0; i <= 5; i++) {  // ❌ Bug: <= invece di <
    array[i] = i;  // i=5 scrive OLTRE i limiti!
}

// Cosa succede?
// 1. Corrompi memoria adiacente (potrebbero essere altre variabili!)
// 2. Comportamento imprevedibile
// 3. Possibili crash
// 4. Vulnerabilità di sicurezza (buffer overflow exploit)

free(array);

// ✅ CORRETTO
int *array2 = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {  // ✅ Usa <
    array2[i] = i;
}
free(array2);

// ❌ USE AFTER FREE
char *str = (char*)malloc(20);
strcpy(str, "Hello");

free(str);

// Memoria liberata, ma...
printf(">%s\n", str);  // ❌ USE AFTER FREE!

// Perché è pericoloso?
// La memoria è stata liberata e potrebbe essere:
// 1. Ancora lì (per caso) - sembra funzionare!
// 2. Riassegnata a qualcun altro - dati corrotti!
// 3. Protetta dal sistema - CRASH!

str[0] = 'X';  // ❌ ANCORA PEGGIO: modifica memoria liberata!

# Compila con simboli di debug
gcc -g -Wall -Wextra programma.c -o programma

# Esegui con Valgrind
valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes ./programma

# Output esempio:
# ==12345== HEAP SUMMARY:
# ==12345==     in use at exit: 400 bytes in 1 blocks
# ==12345==   total heap usage: 1 allocs, 0 frees, 400 bytes allocated
# ==12345==
# ==12345== 400 bytes in 1 blocks are definitely lost in loss record 1 of 1
# ==12345==    at 0x4C2FB0F: malloc (in /usr/lib/valgrind/...)
# ==12345==    by 0x108656: main (programma.c:10)
# 
# Valgrind ti dice ESATTAMENTE dove hai dimenticato la free()!

# Compila con AddressSanitizer
gcc -g -fsanitize=address -fno-omit-frame-pointer programma.c -o programma

# Esegui normalmente - ASan ti avviserà degli errori
./programma

# ASan rileva:
# - Buffer overflow
# - Use after free
# - Use after return
# - Memory leak
# - Double free

# Avvia GDB
gdb ./programma

# Comandi utili:
(gdb) break main          # Breakpoint
(gdb) run                 # Esegui
(gdb) print ptr           # Stampa valore puntatore
(gdb) print *ptr          # Stampa valore puntato
(gdb) x/10x ptr          # Esamina 10 valori hex da ptr
(gdb) watch *ptr          # Watchpoint (fermati quando cambia)

typedef struct {
    void *memoria;
    size_t dimensione_blocco;
    size_t num_blocchi;
    bool *occupati;
} MemoryPool;

MemoryPool* crea_pool(size_t blocco_size, size_t num) {
    MemoryPool *pool = malloc(sizeof(MemoryPool));
    if (!pool) return NULL;
    
    pool->memoria = malloc(blocco_size * num);
    pool->occupati = calloc(num, sizeof(bool));
    
    if (!pool->memoria || !pool->occupati) {
        free(pool->memoria);
        free(pool->occupati);
        free(pool);
        return NULL;
    }
    
    pool->dimensione_blocco = blocco_size;
    pool->num_blocchi = num;
    
    return pool;
}

void* alloca_da_pool(MemoryPool *pool) {
    for (size_t i = 0; i < pool->num_blocchi; i++) {
        if (!pool->occupati[i]) {
            pool->occupati[i] = true;
            return (char*)pool->memoria + (i * pool->dimensione_blocco);
        }
    }
    return NULL;  // Pool pieno
}